/**
 * 跨平台消息通知工具类
 * 统一处理震动和声音提醒功能
 */

class NotificationService {
  /**
   * 触发设备提醒（震动+声音）
   * @param {Object} options - 提醒选项
   * @param {Boolean} options.vibrate - 是否震动
   * @param {Boolean} options.sound - 是否播放声音
   * @param {String} options.platform - 指定平台（可选）
   */
  static async triggerNotification(options = {}) {
    const defaultOptions = {
      vibrate: true,
      sound: true
    };
    
    const opts = Object.assign({}, defaultOptions, options);
    
    // 检查是否为用户自己发送的消息
    if (this.isSelfMessage(options.senderId)) {
      return;
    }
    
    // 检查用户设置
    const userSettings = await this.getUserNotificationSettings();
    if (!userSettings.enableNotification) {
      return;
    }
    
    // 检查是否在免打扰时段
    if (this.isQuietHours(userSettings.quietHours)) {
      return;
    }
    
    // 触发震动
    if (opts.vibrate && userSettings.enableVibrate) {
      this.triggerVibration();
    }
    
    // 播放声音
    if (opts.sound && userSettings.enableSound) {
      this.playNotificationSound();
    }
  }
  
  /**
   * 判断是否为自己发送的消息
   * @param {String|Number} senderId - 发送者ID
   * @returns {Boolean}
   */
  static isSelfMessage(senderId) {
    try {
      const userInfo = uni.getStorageSync('userInfo');
      return userInfo && userInfo.user_id && senderId === userInfo.user_id;
    } catch (e) {
      console.error('获取用户信息失败:', e);
      return false;
    }
  }
  
  /**
   * 获取用户通知设置
   * @returns {Object}
   */
  static async getUserNotificationSettings() {
    // 默认设置
    const defaultSettings = {
      enableNotification: true,
      enableVibrate: true,
      enableSound: true,
      quietHours: {
        start: '22:00',
        end: '08:00'
      }
    };
    
    try {
      const settings = uni.getStorageSync('notificationSettings');
      return Object.assign({}, defaultSettings, settings);
    } catch (e) {
      console.warn('获取通知设置失败，使用默认设置:', e);
      return defaultSettings;
    }
  }
  
  /**
   * 判断当前是否为免打扰时段
   * @param {Object} quietHours - 免打扰时段设置
   * @returns {Boolean}
   */
  static isQuietHours(quietHours) {
    if (!quietHours || !quietHours.start || !quietHours.end) {
      return false;
    }
    
    const now = new Date();
    const currentTime = now.getHours() * 60 + now.getMinutes();
    
    const [startHour, startMinute] = quietHours.start.split(':').map(Number);
    const [endHour, endMinute] = quietHours.end.split(':').map(Number);
    
    const startTime = startHour * 60 + startMinute;
    const endTime = endHour * 60 + endMinute;
    
    // 处理跨日期的情况（如 22:00 - 08:00）
    if (startTime > endTime) {
      return currentTime >= startTime || currentTime <= endTime;
    } else {
      return currentTime >= startTime && currentTime <= endTime;
    }
  }
  
  /**
   * 触发震动提醒
   */
  static triggerVibration() {
    // #ifdef APP-PLUS
    try {
      const systemInfo = uni.getSystemInfoSync ? uni.getSystemInfoSync() : uni.getWindowInfo();
      const platform = systemInfo.platform;
      if (platform === 'ios') {
        plus.device.vibrate();
      } else if (platform === 'android') {
        plus.device.vibrate(500);
      }
    } catch (e) {
      console.error('App震动失败:', e);
      // 降级到uni API
      uni.vibrateLong();
    }
    // #endif
    
    // #ifndef APP-PLUS
    uni.vibrateLong({
      success: function () {
        console.log('设备震动成功');
      },
      fail: function (err) {
        console.error('设备震动失败:', err);
      }
    });
    // #endif
  }
  
  /**
   * 播放通知声音
   */
  static playNotificationSound() {
    // #ifdef APP-PLUS
    try {
      const systemInfo = uni.getSystemInfoSync ? uni.getSystemInfoSync() : uni.getWindowInfo();
      const platform = systemInfo.platform;
      if (platform === 'android') {
        // Android平台播放系统默认通知声音
        let main = plus.android.runtimeMainActivity();
        let RingtoneManager = plus.android.importClass("android.media.RingtoneManager");
        let uri = RingtoneManager.getActualDefaultRingtoneUri(main, RingtoneManager.TYPE_NOTIFICATION);
        let MediaPlayer = plus.android.importClass("android.media.MediaPlayer");
        let player = MediaPlayer.create(main, uri);
        player.setLooping(false);
        player.prepare();
        player.start();
        return;
      } else if (platform === 'ios') {
        // iOS平台使用系统声音API
        let AudioServices = plus.ios.importClass("AudioToolbox/AudioServices.h");
        AudioServices.AudioServicesPlaySystemSound(1007); // 1007是iOS的消息提示音
        return;
      }
    } catch (e) {
      console.error('播放系统提示音失败:', e);
    }
    // #endif
    
    // 其他平台不播放自定义声音，依赖系统默认提示音
    // 小程序等平台通常会自动触发系统提示音
  }
  
  /**
   * 显示系统通知（适用于App平台）
   * @param {Object} messageData - 消息数据
   * @param {String} type - 消息类型 ('private_message' 或 'system_notification')
   */
  static showSystemNotification(messageData, type = 'private_message') {
    // #ifdef APP-PLUS
    try {
      // 确保消息数据存在
      if (!messageData) {
        console.warn('消息数据为空');
        return;
      }
      
      let title = '新消息';
      if (type === 'private_message') {
        title = messageData?.sender?.name || '私聊消息';
      } else if (type === 'system_notification') {
        title = messageData.title || '系统通知';
      }
      
      // 显示系统通知
      const content = type === 'private_message' ? 
        messageData.content : 
        (messageData.content || messageData.message);
      
      console.log('准备创建推送通知:', {
        title: title,
        content: content,
        type: type
      });
      
      // 检查推送服务是否可用
      const clientInfo = plus.push.getClientInfo();
      console.log('推送客户端信息:', clientInfo);
      
      if (!clientInfo || !clientInfo.token) {
        console.warn('推送服务不可用，可能未授权');
        return;
      }
      
      // 构造 payload 数据
      const payload = {
        type: type,
        data: messageData
      };
      
      // 创建推送通知
      const options = {
        title: title,
        sound: "system",
        cover: true,
        when: new Date().getTime()
      };
      
      // 确保应用在前台时也能显示通知
      const notification = plus.push.createMessage(content, JSON.stringify(payload), options);
      
      console.log('推送通知创建成功:', notification);
    } catch (e) {
      console.error('创建系统通知失败:', e);
    }
    // #endif
  }
}

export default NotificationService;